package com.shopping.service;

import java.util.Date;
import java.util.List;
import java.util.Objects;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.shopping.dao.Impl.IItemsDao;
import com.shopping.dao.Impl.OrdersDao;
import com.shopping.model.Carts;
import com.shopping.model.Goods;
import com.shopping.model.Items;
import com.shopping.model.Orders;
import com.shopping.model.Users;
import com.shopping.service.impl.CartsService;
import com.shopping.service.impl.ItemServiceImpl;
import com.shopping.service.impl.UsersServiceImpl;
import com.shopping.utils.ExceptionConfig;
import com.shopping.utils.ExceptionConfig.MyException;


@Service
public class OrdersService {

	@Autowired
	private OrdersDao ordersDao;

	@Autowired
	private ItemServiceImpl itemsService;

	@Autowired
	private IGoodsService goodsService;

	@Autowired
	private UsersServiceImpl usersService;

	@Autowired
	private CartsService cartsService;

	@Autowired
	private IItemsDao itemsDao;

	public List<Orders> orderList(byte status, int page, int size) {
		// 分页查询订单
		List<Orders> orderList = ordersDao.orderList(status, (page - 1) * size, size);
		// 查询每个订单的订单项和客户
		for (Orders order : orderList) {
			// 查询订单的订单项，并设置进订单中
			List<Items> items = itemsService.getItemsByOrderId(order.getId());
			// 循环查询每一个订单项的商品详情
			for (Items item : items) {
				Goods good = goodsService.findById(item.getGoodId());
				item.setGood(good);
			}
			order.setItemList(items);
			// 查询订单的客户，并设置进订单中
			Users user = usersService.getById(order.getUserId());
			order.setUser(user);
		}
		System.out.println(orderList);
		return orderList;
	}

	public long getCountsByStatus(byte status) {
		return ordersDao.getCountsByStatus(status);
	}

	public void orderUpdate(int id, byte status) {
		ordersDao.orderUpdate(id, status);
	}

	public void orderDelete(int id) {
		// 删除订单
		ordersDao.orderDelete(id);
		// 删除订单项
		itemsService.itemsDelete(id);
	}

	/**
	 * 保存订单
	 * 
	 * @param order
	 * @throws MyException
	 */
	// 做了事务控制，不用担心出了异常已做的数据库操作会提交。
	@Transactional
	public int save(int userId) throws MyException {

		// 防止没有选择商品就去结算。
		List<Carts> cartList = cartsService.getList(userId);
		if (Objects.isNull(cartList) || cartList.isEmpty()) {
			throw new ExceptionConfig.MyException("购物车没有商品");
		}

		// 1.更新库存
		for (Carts cart : cartList) {
			if (cart.getGood().getStock() < cart.getAmount()) { // 验证库存
				throw new ExceptionConfig.MyException("商品 [ " + cart.getGood().getName() + " ] 库存不足");
			}
			// 库存充足，则先更新商品的库存和销售量。
			goodsService.updateStock(cart.getGood().getId(), cart.getAmount()); // 减库存
			goodsService.updateSales(cart.getGood().getId(), cart.getAmount()); // 加销量
		}

		// 2. 保存订单。
		// 计算此次订单的总价格、总数量。
		int total = 0; // 订单总价
		for (Carts cart : cartList) {
			total += cart.getGood().getPrice() * cart.getAmount();
		}
		Orders order = new Orders();
		order.setUserId(userId);
		order.setTotal(total);
		order.setAmount(cartList.size());
		order.setStatus(Orders.STATUS_UNPAY);
		order.setSystime(new Date());
		ordersDao.insert(order);

		// 3. 保存订单项
		int orderId = order.getId();
		for (Carts cart : cartList) {
			Items item = new Items();
			item.setOrderId(orderId);
			item.setGoodId(cart.getGoodId());
			item.setPrice(cart.getGood().getPrice());
			item.setAmount(cart.getAmount());
			itemsDao.insert(item);
		}

		// 4. 清空当前用户的购物车
		cartsService.clean(userId);

		return orderId;
	}

	/**
	 * 通过id获取
	 * 
	 * @param id
	 * @return
	 */
	public Orders get(int id) {
		return pack(ordersDao.select(id));
	}

	/**
	 * 封装
	 * 
	 * @param order
	 * @return
	 */
	private Orders pack(Orders order) {
		if (Objects.nonNull(order)) {
			// 根据订单ID查询对应的所有订单项。
			List<Items> itemList = itemsDao.selectList(order.getId());
			for (Items item : itemList) {
				// 查询订单项的商品详情。
				item.setGood(goodsService.findById(item.getGoodId()));
			}
			order.setItemList(itemList);

			// 查询订单的用户信息。
			order.setUser(usersService.getById(order.getUserId()));
		}
		return order;
	}

	/**
	 * 订单支付
	 * 
	 * @param order
	 */
	public void pay(Orders order) {

		Orders old = ordersDao.select(order.getId());
		old.setStatus(Orders.STATUS_PAYED); // 只要设置状态为已支付。 其他不变。
		old.setPaytype(order.getPaytype());
		old.setName(order.getName());
		old.setPhone(order.getPhone());
		old.setAddress(order.getAddress());

		ordersDao.update(old);
	}

	/**
	 * 	查询我的订单，根据登录用户的ID分页查询该用户的订单
	 */
	public Object orderListByUserId(int userId, int page, int size) {
		// 分页查询我的订单
		List<Orders> orderList = ordersDao.orderListByUserId(userId, (page - 1) * size, size);
		// 查询每个订单的订单项和客户
		for (Orders order : orderList) {
			// 查询订单的订单项，并设置进订单中
			List<Items> items = itemsService.getItemsByOrderId(order.getId());
			// 循环查询每一个订单项的商品详情
			for (Items item : items) {
				Goods good = goodsService.findById(item.getGoodId());
				item.setGood(good);
			}
			order.setItemList(items);
			// 查询订单的客户，并设置进订单中
			Users user = usersService.getById(order.getUserId());
			order.setUser(user);
		}
		return orderList;
	}

	/**
	 * 	查询我的订单的数量
	 * @param userId
	 * @return
	 */
	public long getCountsByUserId(int userId) {
		return ordersDao.getCountsByUserId(userId);
	}
}
